oa.apt.additionOf1 = new ArithmeticProblemType(
  "AdditionOf1",
  "Addition of 1",
  1,
  [ null,{lb:0,ub:9},{lb:1,ub:1}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.additionOf2 = new ArithmeticProblemType(
  "AdditionOf2",
  "Addition of 2",
  1,
  [ null,{lb:0,ub:8},{lb:2,ub:2}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
  );
oa.apt.additionOf3 = new ArithmeticProblemType(
  "AdditionOf3",
  "Addition of 3",
  1,
  [ null,{lb:0,ub:7},{lb:3,ub:3}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
  );
oa.apt.additionOf4 = new ArithmeticProblemType(
  "AdditionOf4",
  "Addition of 4",
  1,
  [ null,{lb:0,ub:6},{lb:4,ub:4}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
  );
oa.apt.additionOf5 = new ArithmeticProblemType(
  "AdditionOf5",
  "Addition of 5",
  1,
  [ null,{lb:0,ub:5},{lb:5,ub:5}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
  );
oa.apt.additionOf6 = new ArithmeticProblemType(
    "AdditionOf6",
    "Addition of 6",
    1,
    [ null,{lb:0,ub:4},{lb:6,ub:6}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
    );
oa.apt.additionOf7 = new ArithmeticProblemType(
    "AdditionOf7",
    "Addition of 7",
    1,
    [ null,{lb:0,ub:5},{lb:7,ub:7}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
    );
oa.apt.additionOf8 = new ArithmeticProblemType(
    "AdditionOf8",
    "Addition of 8",
    1,
    [ null,{lb:0,ub:4},{lb:8,ub:8}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
    );
oa.apt.additionOf9 = new ArithmeticProblemType(
    "AdditionOf9",
    "Addition of 9",
    1,
    [ null,{lb:0,ub:3},{lb:9,ub:9}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
    );
oa.apt.simpleAddition12 = new ArithmeticProblemType(
  "SimpleAddition12",
  "Addition with a sum between 7 and 12",
  1,
  [ {lb:7,ub:12},{lb:1,ub:9},{lb:1,ub:9}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.basicAddition = new ArithmeticProblemType(
  "BasicAddition18",
  "Basic addition with a sum between 10 and 20",
  1,
  [ {lb:10,ub:20},{lb:2,ub:10},{lb:2,ub:10}], 
  [ OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.simpleAdditionWithAskedForOperand1 = new ArithmeticProblemType(
    "SimpleAdditionWithAskedForOperand2",
    "Basic addition where the second summand is asked for (with a result up to 10)",
    1,
    [ {lb:0,ub:10},{lb:0,ub:9},{lb:0,ub:9}], // result number range enforces non-negative integers
    [ OperatorEL.plus],      // operators
    1       // askedFor = "operand 1"
  );
oa.apt.simpleAdditionWithAskedForOperand2 = new ArithmeticProblemType(
    "SimpleAdditionWithAskedForOperand2",
    "Basic addition where the second summand is asked for (with a result up to 10)",
    1,
    [ {lb:0,ub:10},{lb:0,ub:9},{lb:0,ub:9}], // result number range enforces non-negative integers
    [ OperatorEL.plus],      // operators
    2       // askedFor = "operand 2"
  );
oa.apt.basicAdditionWithAskedForOperand2 = new ArithmeticProblemType(
    "BasicAdditionWithAskedForOperand2",
    "Basic addition where the second summand is asked for",
    1,
    [ {lb:10,ub:20},{lb:2,ub:9},{lb:2,ub:9}], // result number range enforces non-negative integers
    [ OperatorEL.plus],      // operators
    2       // askedFor = "operand 2"
  );
oa.apt.basicAdditionWithAskedForOperand1 = new ArithmeticProblemType(
    "BasicAdditionWithAskedForOperand1",
    "Basic addition where the second summand is asked for",
    1,
    [ {lb:10,ub:20},{lb:2,ub:9},{lb:2,ub:9}], // result number range enforces non-negative integers
    [ OperatorEL.plus],      // operators
    1       // askedFor = "operand 1"
  );
oa.apt.simpleAdditionOf3Numbers = new ArithmeticProblemType(
  "SimpleAdditionOf3Numbers",
  "Addition of 3 numbers with a result up to 18",
  1,
  [ {lb:6,ub:18},{lb:0,ub:6},{lb:0,ub:6}, {lb:1,ub:6}],
  [ OperatorEL.plus, OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.additionOf10 = new ArithmeticProblemType(
    "AdditionOf10",
    "Addition of 10",
    1,
    [ null,{lb:0,ub:20},{lb:10,ub:10}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.basicAdditionOf3Numbers = new ArithmeticProblemType(
    "BasicAdditionOf3Numbers",
    "Addition of 3 numbers between 4 and 10",
    1,
    [ {lb:15,ub:30},{lb:4,ub:10},{lb:4,ub:10}, {lb:4,ub:10}],
    [ OperatorEL.plus, OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.simpleAdditionUpTo6 = new ArithmeticProblemType(
  "SimpleAdditionUpTo6",
  "Addition of 2 numbers between 1 and 6",
  1,
  [ null,{lb:1,ub:6},{lb:1,ub:6}],
  [ OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.simpleAdditionOf3NumbersUpTo6 = new ArithmeticProblemType(
  "SimpleAdditionOf3NumbersUpTo6",
  "Addition of 3 numbers between 1 and 6",
  1,
  [ null,{lb:1,ub:6},{lb:1,ub:6}, {lb:1,ub:6}],
  [ OperatorEL.plus, OperatorEL.plus],
  0       // askedFor = "result"
);  
oa.apt.simpleAdditionOf4NumbersUpTo6 = new ArithmeticProblemType(
  "SimpleAdditionOf4NumbersUpTo6",
  "Addition of 4 numbers between 1 and 6",
  1,
  [ null,{lb:1,ub:6},{lb:1,ub:6}, {lb:1,ub:6}, {lb:1,ub:6}],
  [ OperatorEL.plus, OperatorEL.plus, OperatorEL.plus],
  0       // askedFor = "result"
);
oa.apt.simpleSubtractionUpTo6 = new ArithmeticProblemType(
  "SimpleSubtractionUpTo6",
  "Subtraction of 2 numbers between 1 and 6",
  1,
  [ {lb:0,ub:6},{lb:1,ub:6},{lb:1,ub:6}],
  [ OperatorEL.minus],
  0       // askedFor = "result"
);
oa.apt.simpleSubtractionOf2NumbersFirstOperandAsked = new ArithmeticProblemType(
  "SimpleSubtractionOf2NumbersFirstOperandAsked",
  "Basic Subtraction of 2 numbers between 1 and 6",
  1,
  [ {lb:1,ub:6},{lb:0,ub:6},{lb:1,ub:6}],
  [ OperatorEL.minus],
  1       // askedFor = "result"
);
oa.apt.simpleSubtractionOf2NumbersSecondOperandAsked = 
		new ArithmeticProblemType(
  "SimpleSubtractionOf2NumbersSecondOperandAsked",
  "Basic Subtraction of 2 numbers between 1 and 6",
  1,
  [ {lb:1,ub:6},{lb:1,ub:6},{lb:0,ub:6}],
  [ OperatorEL.minus],
  2       // askedFor = "result"
);
oa.apt.basicAdditionOf4Numbers = new ArithmeticProblemType(
    "BasicAdditionOf4Numbers",
    "Basic Addition of 4 numbers",
    1,
    [ {lb:20,ub:30},{lb:4,ub:10},{lb:4,ub:10}, {lb:4,ub:10}, {lb:4,ub:10}],
    [ OperatorEL.plus, OperatorEL.plus, OperatorEL.plus],
    0       // askedFor = "result"
  );
//-----------------------------------------------------------
oa.apt.additionOf20 = new ArithmeticProblemType(
    "AdditionOf20",
    "Addition of 20",
    1,
    [ null,{lb:0,ub:80},{lb:20,ub:20}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.additionOf30 = new ArithmeticProblemType(
    "AdditionOf30",
    "Addition of 30",
    1,
    [ null,{lb:0,ub:70},{lb:30,ub:30}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.additionOf40 = new ArithmeticProblemType(
    "AdditionOf40",
    "Addition of 40",
    1,
    [ null,{lb:0,ub:60},{lb:40,ub:40}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.additionOf50 = new ArithmeticProblemType(
    "AdditionOf50",
    "Addition of 50",
    1,
    [ null,{lb:0,ub:50},{lb:50,ub:50}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.addition30 = new ArithmeticProblemType(
    "Addition30",
    "Addition with a sum of up to 30",
    1,
    [ {lb:20,ub:30},{lb:3,ub:20},{lb:3,ub:20}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.addition50 = new ArithmeticProblemType(
    "Addition50",
    "Addition with a sum of up to 50",
    1,
    [ {lb:30,ub:50},{lb:10,ub:40},{lb:10,ub:40}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.addition100 = new ArithmeticProblemType(
    "Addition100",
    "Addition with a sum of up to 100",
    1,
    [ {lb:50,ub:100},{lb:10,ub:60},{lb:10,ub:60}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.addition1000 = new ArithmeticProblemType(
    "Addition1000",
    "Addition with a sum of up to 1000",
    1,
    [ null,{lb:100,ub:500},{lb:100,ub:500}], 
    [ OperatorEL.plus],
    0       // askedFor = "result"
  );
oa.apt.additionWithAskedForOperand2 = new ArithmeticProblemType(
    "BasicAdditionWithAskedForOperand2",
    "Basic addition where the second summand is asked for",
    1,
    [ null,{lb:10,ub:50},{lb:10,ub:50}], 
    [ OperatorEL.plus],      // operators
    2       // askedFor = "operand 2"
  );
//-----------------------------------------------------------
oa.apt.subtractionOf1 = new ArithmeticProblemType(
    "SubtractionOf1",
    "Subtraction of 1",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:1,ub:1}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtractionOf2 = new ArithmeticProblemType(
    "SubtractionOf2",
    "Subtraction of 2",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:2,ub:2}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtractionOf3 = new ArithmeticProblemType(
    "SubtractionOf3",
    "Subtraction of 3",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:3,ub:3}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtractionOf4 = new ArithmeticProblemType(
    "SubtractionOf4",
    "Subtraction of 4",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:4,ub:4}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtractionOf5 = new ArithmeticProblemType(
    "SubtractionOf5",
    "Subtraction of 5",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:5,ub:5}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtractionOf9 = new ArithmeticProblemType(
    "SubtractionOf5",
    "Subtraction of 5",
    1,
    [ {lb:0,ub:10},{lb:0,ub:10},{lb:9,ub:9}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.simpleSubtraction = new ArithmeticProblemType(
  "BasicSubtraction10",
  "Subtraction from numbers up to 10",
  1,
  [ {lb:0,ub:10},{lb:0,ub:10},{lb:0,ub:10}],  // result number range enforces non-negative integers
  [ OperatorEL.minus],       // operators
  0       // askedFor = "result"
);
oa.apt.basicSubtraction = new ArithmeticProblemType(
    "BasicSubtraction20",
    "Basic subtraction from up to 20",
    1,
    [ {lb:0,ub:20},{lb:10,ub:20},{lb:2,ub:10}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtraction50 = new ArithmeticProblemType(
    "Subtraction50",
    "Basic subtraction from up to 50",
    1,
    [ {lb:0,ub:100},{lb:20,ub:50},{lb:10,ub:40}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.subtraction100 = new ArithmeticProblemType(
    "Subtraction100",
    "Basic subtraction from up to 100",
    1,
    [ {lb:0,ub:100},{lb:50,ub:100},{lb:10,ub:50}],  // result number range enforces non-negative integers
    [ OperatorEL.minus],       // operators
    0       // askedFor = "result"
  );
oa.apt.additionSubtraction = new ArithmeticProblemType(
  "AdditionSubtraction",
  "Addition followed by subtraction",
  1,
  [ {lb:0,ub:20},{lb:1,ub:10},{lb:1,ub:10},{lb:1,ub:10}], // result number range enforces non-negative integers
  [ OperatorEL.plus, OperatorEL.minus],      // operators
  0       // askedFor = "result"
);
oa.apt.subtractionAddition = new ArithmeticProblemType(
    "SubtractionAddition",
    "Subtraction followed by addition",
    1,
    [ {lb:0,ub:20},{lb:1,ub:20},{lb:1,ub:10},{lb:1,ub:10}], // result number range enforces non-negative integers
    [ OperatorEL.minus, OperatorEL.plus],      // operators
    0       // askedFor = "result"
  );
oa.apt.doubleSubtraction = new ArithmeticProblemType(
    "DoubleSubtraction",
    "Two chained subtractions",
    1,
    [ {lb:0,ub:20},{lb:0,ub:20},{lb:1,ub:10},{lb:1,ub:10}], // result number range enforces non-negative integers
    [ OperatorEL.minus, OperatorEL.minus],      // operators
    0       // askedFor = "result"
  );
//-----------------------------------------------------------
oa.apt.multiplicationBy2 = new ArithmeticProblemType(
  "MultiplicationBy2",
  "Multiplication by 2",
  1,
  [ null,{lb:0,ub:10},{lb:2,ub:2}], 
  [ OperatorEL.times],
  0       // askedFor = "result"
);
oa.apt.multiplicationBy3 = new ArithmeticProblemType(
    "MultiplicationBy3",
    "Multiplication by 3",
    1,
    [ null,{lb:0,ub:10},{lb:3,ub:3}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy4 = new ArithmeticProblemType(
    "MultiplicationBy4",
    "Multiplication by 4",
    1,
    [ null,{lb:0,ub:10},{lb:4,ub:4}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy5 = new ArithmeticProblemType(
    "MultiplicationBy5",
    "Multiplication by 5",
    1,
    [ null,{lb:0,ub:10},{lb:5,ub:5}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy6 = new ArithmeticProblemType(
    "MultiplicationBy6",
    "Multiplication by 6",
    1,
    [ null,{lb:0,ub:10},{lb:6,ub:6}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy7 = new ArithmeticProblemType(
    "MultiplicationBy7",
    "Multiplication by 7",
    1,
    [ null,{lb:0,ub:10},{lb:7,ub:7}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy8 = new ArithmeticProblemType(
    "MultiplicationBy8",
    "Multiplication by 8",
    1,
    [ null,{lb:0,ub:10},{lb:8,ub:8}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.multiplicationBy9 = new ArithmeticProblemType(
    "MultiplicationBy9",
    "Multiplication by 9",
    1,
    [ null,{lb:0,ub:10},{lb:9,ub:9}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
);
oa.apt.basicMultiplication = new ArithmeticProblemType(
    "BasicMultiplication",
    "Basic multiplication with a product between 9 and 100",
    1,
    [ {lb:9,ub:100},{lb:2,ub:10},{lb:2,ub:10}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
  );
oa.apt.multiplication15 = new ArithmeticProblemType(
    "Multiplication15",
    "Multiplication with factors up to 15",
    1,
    [ null,{lb:2,ub:15},{lb:11,ub:15}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
  );
oa.apt.multiplication20 = new ArithmeticProblemType(
    "Multiplication20",
    "Multiplication with factors up to 20",
    1,
    [ null,{lb:11,ub:20},{lb:11,ub:20}], 
    [ OperatorEL.times],
    0       // askedFor = "result"
  );
//-----------------------------------------------------------
oa.apt.timesPlusMinus = new ArithmeticProblemType(
    "MulitplicationAdditionSubtraction",
    "Mulitplication and addition and subtraction",
    1,
    [ {lb:0,ub:100},{lb:4,ub:12},{lb:4,ub:12},{lb:15,ub:25},{lb:20,ub:50}], 
    [ OperatorEL.times, OperatorEL.plus, OperatorEL.minus],      
    0       // askedFor = "result"
  );

//------------------------------------------------------------

oa.apt.divisionBy1 = new ArithmeticProblemType(
  "DivisionOf1",
  "Division Of 1",
  1,
  [ null,{lb:0,ub:10},{lb:1,ub:1}], 
  [ OperatorEL.dividedBy],
  0       // askedFor = "result"
  );
oa.apt.divisionBy2 = new ArithmeticProblemType(
  "DivisionOf2",
  "Division Of 2",
  1,
  [ null,{lb:0,ub:20},{lb:2,ub:2}], 
  [ OperatorEL.dividedBy],
  0       // askedFor = "result"
  );
oa.apt.divisionBy3 = new ArithmeticProblemType(
  "DivisionOf3",
  "Division Of 3",
  1,
  [ null,{lb:0,ub:30},{lb:3,ub:3}], 
  [ OperatorEL.dividedBy],
  0       // askedFor = "result"
  );
oa.apt.divisionBy4 = new ArithmeticProblemType(
  "DivisionOf4",
  "Division Of 4",
  1,
  [ null,{lb:0,ub:40},{lb:4,ub:4}], 
  [ OperatorEL.dividedBy],
  0       // askedFor = "result"
 );
oa.apt.divisionBy5 = new ArithmeticProblemType(
  "DivisionOf5",
  "Division Of 5",
  1,
  [ null,{lb:0,ub:50},{lb:5,ub:5}], 
  [ OperatorEL.dividedBy],
  0       // askedFor = "result"
  );
oa.apt.basicDivision = new ArithmeticProblemType(
    "BasicDivision",
    "Division from up to 100",
    1,
    [ {lb:2,ub:10},{lb:4,ub:100},{lb:2,ub:10}], 
    [ OperatorEL.dividedBy],
    0       // askedFor = "result"
    );
oa.apt.division200 = new ArithmeticProblemType(
    "Division200",
    "Division from up to 200",
    1,
    [ {lb:2,ub:10},{lb:4,ub:200},{lb:10,ub:20}], 
    [ OperatorEL.dividedBy],
    0       // askedFor = "result"
    );
//------------------------------------------------------------


oa.apt.fractionPlusSameDenom = new ArithmeticProblemType(
  "Fraction1",
  "Fraction1",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [ OperatorEL.plus, OperatorEL.plus],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.SameDenominator,
  NumDenomOrBothEL.both, // both
  false, // reduced
  true // mixed
  );

oa.apt.fractionPlusLCM = new ArithmeticProblemType(
  "Fraction2",
  "Fraction2",
  NumberTypeEL.Fraction,
  [{lb:1,ub:189, lbD:1, ubD:162},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD: 18}] , 
  [ OperatorEL.plus],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.DenominatorEqualsLCM,
  NumDenomOrBothEL.both, // numerator
  false, // reduced
  true // mixed
  );

oa.apt.fractionPlusNormal = new ArithmeticProblemType(
  "Fraction3",
  "Fraction3",
  NumberTypeEL.Fraction,
  [{lb:1,ub:153, lbD:1, ubD:72},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [ OperatorEL.plus],
  0,  // askedFor = "result"
  undefined,  // SpecialProblemCategory
  NumDenomOrBothEL.both, // both
  true, // reduced
  true // mixed
  );

oa.apt.fractionPlusNatural = new ArithmeticProblemType(
    "Fraction3",
    "Fraction3",
    NumberTypeEL.Fraction,
    [{lb:1,ub:153, lbD:1, ubD:72},{lb:1,ub:9, lbD:1, ubD:1},{lb:1,ub:9, lbD:1, ubD:9}] , 
    [ OperatorEL.plus],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.DenominatorEqualsLCM,  // SpecialProblemCategory
    NumDenomOrBothEL.both, // both
    true, // reduced
    true // mixed
    );

oa.apt.fractionMinusSameDenom = new ArithmeticProblemType(
  "Fraction3",
  "Fraction3",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:18, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [ OperatorEL.minus],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.SameDenominator,
  NumDenomOrBothEL.both, // numerator
  false, // reduced
  true // mixed
  );

oa.apt.fractionMinusLCM = new ArithmeticProblemType(
  "Fraction3",
  "Fraction3",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:189, lbD:1, ubD:20},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [ OperatorEL.minus],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.DenominatorEqualsLCM,
  NumDenomOrBothEL.both, // both
  false, // reduced
  true // mixed
  );

oa.apt.fractionMinusNormal = new ArithmeticProblemType(
  "Fraction3",
  "Fraction3",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:153, lbD:1, ubD:72},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [ OperatorEL.minus],
  1,// askedFor = "result"
  undefined,  // SpecialProblemCategory
  NumDenomOrBothEL.both, // denom
  false, // reduced
  true // mixed
  );

oa.apt.fractionMinusNatural = new ArithmeticProblemType(
    "Fraction3",
    "Fraction3",
    NumberTypeEL.Fraction,
    [{lb:1,ub:9, lbD:2, ubD:9},{lb:1,ub:153, lbD:1, ubD:72},{lb:1,ub:9, lbD:1, ubD:1}] , 
    [ OperatorEL.minus],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.DenominatorEqualsLCM, // other
    NumDenomOrBothEL.both, // denom
    false, // reduced
    true // mixed
    );

oa.apt.fractionTimesLCM = new ArithmeticProblemType(
  "Fraction33",
  "Fraction33",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:188},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:18}] , 
  [ OperatorEL.times],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.DenominatorEqualsLCM,
  NumDenomOrBothEL.both, // both
  false, // reduced
  true // mixed
  );

oa.apt.fractionTimesSameDenom = new ArithmeticProblemType(
    "Fraction33",
    "Fraction33",
    NumberTypeEL.Fraction,
    [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
    [ OperatorEL.times],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.SameDenominator,
    NumDenomOrBothEL.both, // both
    false, // reduced
    true // mixed
    );

oa.apt.fractionTimesNatural = new ArithmeticProblemType(
    "Fraction33",
    "Fraction33",
    NumberTypeEL.Fraction,
    [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:1}] , 
    [ OperatorEL.times],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.DenominatorEqualsLCM,
    NumDenomOrBothEL.both, // both
    true, // reduced
    true // mixed
    );

oa.apt.fractionDivideLCM = new ArithmeticProblemType(
  "Fraction3",
  "Fraction3",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:188},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:18}] , 
  [ OperatorEL.dividedBy],
  0,// askedFor = "result"
  SpecialProblemCategoryEL.DenominatorEqualsLCM,
  NumDenomOrBothEL.both, // both
  false, // reduced
  true // mixed
  );

oa.apt.fractionDivideSameDenom = new ArithmeticProblemType(
    "Fraction3",
    "Fraction3",
    NumberTypeEL.Fraction,
    [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
    [ OperatorEL.dividedBy],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.SameDenominator,
    NumDenomOrBothEL.both, // both
    false, // reduced
    true // mixed
    );

oa.apt.fractionDivideNatural = new ArithmeticProblemType(
    "Fraction3",
    "Fraction3",
    NumberTypeEL.Fraction,
    [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:1}] , 
    [ OperatorEL.dividedBy],
    0,// askedFor = "result"
    SpecialProblemCategoryEL.DenominatorEqualsLCM,
    NumDenomOrBothEL.both, // both
    false, // reduced
    true // mixed
    );

oa.apt.fractionCircle = new ArithmeticProblemType(
  "Segment of circle",
  "Segment of circle",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:2,ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.RecognizeNumber,
  NumDenomOrBothEL.both, // both
  false,
  false
  );

oa.apt.numberComparison = new ArithmeticProblemType(
  "Compare Numbers",
  "Compare Numbers",
  NumberTypeEL.NonNegativeInteger,
  [null,{lb:1,ub:9},{lb:1,ub:9},{lb:1,ub:9},{lb:1,ub:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.SortingNumbers
  );

oa.apt.fractionComparisonNum = new ArithmeticProblemType(
  "Compare Fractions",
  "Compare Fractions",
  NumberTypeEL.Fraction,
  [null,{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.SortingNumbers,
  NumDenomOrBothEL.numerator,
  false,
  false
  );

oa.apt.fractionComparisonDenom = new ArithmeticProblemType(
  "Compare Fractions",
  "Compare Fractions",
  NumberTypeEL.Fraction,
  [null,{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.SortingNumbers,
  NumDenomOrBothEL.denominator,
  false,
  false
  );

oa.apt.fractionComparisonBoth = new ArithmeticProblemType(
  "Compare Fractions",
  "Compare Fractions",
  NumberTypeEL.Fraction,
  [null,{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.SortingNumbers,
  NumDenomOrBothEL.both,
  false,
  false
  );

oa.apt.fractionExtendAndReduce = new ArithmeticProblemType(
    "Extend and Reduce Fractions",
    "Find extended and reduced fractions whose values are equal",
    NumberTypeEL.Fraction,
    [{lb:1,ub:30, lbD:1, ubD:30}] , 
    [OperatorEL.times],
    0, // askedFor = "result"
    SpecialProblemCategoryEL.EquivalentFractions,
    NumDenomOrBothEL.both,
    false,
    false
    );
oa.apt.fractionSquare = new ArithmeticProblemType(
  "Segment of square",
  "Segment of square",
  NumberTypeEL.Fraction,
  [{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9},{lb:1,ub:9, lbD:1, ubD:9}] , 
  [OperatorEL.times],
  0, // askedFor = "result"
  SpecialProblemCategoryEL.RecognizeNumber,
  NumDenomOrBothEL.both, // both
  false,
  false
  );